// $Id: creepblock1.cpp 14 2008-02-23 15:12:07Z msaushkin $
/**
* @file
* Реализация пространства имён creepblock1, используемого для расчёта неупругих деформаций по одноосной 
*  модели

* @author Саушкин М.Н.
*/

#include<iostream>
#include<math.h>
#include "creepblock1.hpp"


/**
* 
* 
*/
namespace creepblock1{
   /** Основные параметры математической модели.
   */
   creep_params params;
//   plast_params plastparams;
 
   int constinit(const void * cr);
   void paraminfo();
   double calcdW (double S,  double dT, double Om);
   double calcdUk(int k, double S, double dT, double Uk, double Om); 
   double calcdVk(int k, double S, double dT, double Vk, double Om); 
   double calcdOm(double S, double dP, double Om);
   double calcdCr(double S, double dP, double Om);
   double getmu1();
   double getmu2();
   char*  getdescription();
   double getalphaA();
   double getmA();
   double getalpha1();
   double getm3();
   double getc();
   double getm1();
   double getsigmazv();
   double getlambdak1();
   double getlambdak2();
   double getak1();
   double getak2();
   double getn2();
   double getk();

   /** Вычисление функции \f$\alpha(\sigma)\f$, используемой в вычислении 
   *  параметра повреждённости \f$\omega\f$
   */
   double alpha(double S  //!< \f$\sigma(t)\f$ - номинальное напряжение (кг/мм\f$^2\f$).
               );

   /** Вычисление функции \f$A_*^c(\sigma^0)\f$, используемой в вычислении 
   *  критерия разрушения
   */
   double A(double S  //!< \f$\sigma(t)\f$ - номинальное напряжение (кг/мм\f$^2\f$).
               );
};

int creepblock1::constinit(const void * cr){
   struct creep_params * here_creep = (struct creep_params *)cr;
   params.description = (here_creep->description);
   params.sigmazv     = (here_creep->sigmazv);
   params.k           = (here_creep->k);
   params.lambdak1    = (here_creep->lambdak1);
   params.lambdak2    = (here_creep->lambdak2);
   params.ak1         = (here_creep->ak1);
   params.ak2         = (here_creep->ak2);
   params.bk1         = (here_creep->bk1);
   params.bk2         = (here_creep->bk2);
   params.c           = (here_creep->c);
   params.n2          = (here_creep->n2);
   params.m1          = (here_creep->m1);
   params.alpha1      = (here_creep->alpha1);
   params.m3          = (here_creep->m3);
   params.alphaA      = (here_creep->alphaA);
   params.mA          = (here_creep->mA);
   params.mu1         = (here_creep->mu1);
   params.mu2         = (here_creep->mu2);
   return 1;
}

void creepblock1::paraminfo(){
   std::cout << "description = " << params.description <<  "\n";
   std::cout << "sigmazv     = " << params.sigmazv << "\n";
   std::cout << "k           = " << params.k << "\n";
   std::cout << "lambdak1    = " << params.lambdak1 << "\n";
   std::cout << "lambdak2    = " << params.lambdak2 << "\n";
   std::cout << "ak1         = " << params.ak1 << "\n";
   std::cout << "ak2         = " << params.ak2 << "\n";
   std::cout << "bk1         = " << params.bk1 << "\n";
   std::cout << "bk2         = " << params.bk2 << "\n";
   std::cout << "c           = " << params.c << "\n";
   std::cout << "n2          = " << params.n2 << "\n";
   std::cout << "m1          = " << params.m1 << "\n";
   std::cout << "alpha1      = " << params.alpha1 << "\n";
   std::cout << "m3          = " << params.m3 << "\n";
   std::cout << "alphaA      = " << params.alphaA << "\n";
   std::cout << "mA          = " << params.mA << "\n";
   std::cout << "mu1         = " << params.mu1 << "\n";
   std::cout << "mu2         = " << params.mu2 << "\n";
};

double creepblock1::calcdW(double S, double dT, double Om){
   double Si = S*(1+Om); // Si - истинное напряжение
   if (fabs(S)>0){
      return params.c*pow(Si/params.sigmazv, params.m1)*dT;}
      else return 0.0;
};

double creepblock1::calcdUk(int k, double S, double dT, double Uk, double Om){
   double Si = S*(1+Om); // Si - истинное напряжение
   switch (k){
      case 1: { 
         if (params.k!=0) {
            return params.lambdak1*(params.ak1*pow(Si/params.sigmazv, params.n2)-Uk)*dT;}
         };
      case 2: { 
         if (params.k==2) {
            return params.lambdak2*(params.ak2*pow(Si/params.sigmazv, params.n2)-Uk)*dT;}
         };
   };
   return 0.0;
};

double creepblock1::calcdVk(int k, double S, double dT, double Vk, double Om){
   double temp;
   double Si = S*(1+Om); // Si - истинное напряжение
   switch (k){
      case 1: { 
         if (params.k!=0) {
            temp = params.bk1*pow(Si/params.sigmazv, params.n2);
            if (temp>Vk){
               return params.lambdak1*(temp-Vk)*dT;}
            else return 0.0;};
         };
      case 2: { 
         if (params.k==2) {
            temp = params.bk2*pow(Si/params.sigmazv, params.n2);
            if (temp>Vk){
               return params.lambdak2*(temp-Vk)*dT;}
            else return 0.0;};
         };
   };
   return 0.0;
};

double creepblock1::alpha(double S){
   return params.alpha1*pow(S, params.m3);
};

double creepblock1::calcdOm(double S, double dP, double Om){
   return alpha(S)*S*(1+Om)*dP;
};

double creepblock1::A(double S){
   return params.alphaA*pow(S, params.mA);
};

double creepblock1::calcdCr(double S, double dP, double Om){
   return S*(1+Om)*dP/A(S);
};

double creepblock1::getmu1(){
   return params.mu1;
};

double creepblock1::getmu2(){
   return params.mu2;
};

char* creepblock1::getdescription(){
   return params.description;
};

double creepblock1::getalphaA(){
   return params.alphaA;
};

double creepblock1::getalpha1(){
   return params.alpha1;
};

double creepblock1::getmA(){
   return params.mA;
};

double creepblock1::getm3(){
   return params.m3;
};

double creepblock1::getc(){
   return params.c;
};

double creepblock1::getm1(){
   return params.m1;
};

double creepblock1::getsigmazv(){
   return params.m1;
};

double creepblock1::getlambdak1(){
   return params.lambdak1;
};

double creepblock1::getlambdak2(){
   return params.lambdak2;
};

double creepblock1::getak1(){
   return params.ak1;
};

double creepblock1::getak2(){
   return params.ak2;
};

double creepblock1::getn2(){
   return params.n2;
};

double creepblock1::getk(){
   return params.k;
};
